package tec;
import java.lang.*;
import poounit.Test;
public class JaugeNaturelTest{
    
    
    public void lancer() throws ClassNotFoundException{
	 int nbTest = 0;
	 System.out.print("."); nbTest++;
	 testDansIntervalle();
	 
	 System.out.print("."); nbTest++;
	 testInferieurIntervalle();

	 System.out.print("."); nbTest++;
	 testDeplacement();
	 
	 System.out.print("."); nbTest++;
	 //testLimiteVigieMaxInferieurVigieMin();

	 System.out.print("."); nbTest++;
	 //testMaxEgaleMin();
	

	 System.out.println("Test Instanciation."); nbTest++;	 
	 testSuperieurIntervalle();
	 
	 System.out.print("."); nbTest++;	 
	 testCreationNonValide();
	 
	 System.out.print("."); nbTest++;	 
	 //testExceptionControlee();

	 System.out.println("OK("+ nbTest + "):JaugeNaturel:");
    }
     
    @Test
    private  void testDansIntervalle(){
	 JaugeNaturel jn = new JaugeNaturel(0,100,2);
	 assert jn.estBleu() == false : "Blue=valeur au dehors de l'intervalle";
	 assert jn.estVert() == true : "Vert=valeur dans l'intervalle";
	 assert jn.estRouge() == false : "Rouge=valeur au dehors de l'intervalle";

    }
    @Test
    private void testDeplacement(){

	 /* Test les méthodes incrementer() et decrementer().

	    Avec une instanciation dans l'intervalle de vigie. par exemple depart == vigieMin + 2.
	    
	    décrémenter pour sortir de l'intervalle.
	    A vérifier :
	    estBleu() retourne vrai.
	    estVert() retourne faux.
	    estRouge() retourne faux.
	    
	    incrémenter le même objet pour revenir dans l'intervalle.
	    A vérifier :
	    estBleu() retourne faux.
	    estVert() retourne vrai.
	    estRouge() retourne faux. 
	 */

	 JaugeNaturel jn = new JaugeNaturel(0,100,1);
	 jn.decrementer();
	 jn.decrementer();
	 assert jn.estBleu() == true : "Blue=valeur au dehors de l'intervalle";
	 assert jn.estVert() == false : "Vert=valeur dans l'intervalle";
	 assert jn.estRouge() == false : "Rouge=valeur au dehors de l'intervalle";
	 jn.incrementer();
	 jn.incrementer();
	 assert jn.estBleu() == false : "Blue=valeur au dehors de l'intervalle";
	 assert jn.estVert() == true : "Vert=valeur dans l'intervalle";
	 assert jn.estRouge() == false : "Rouge=valeur au dehors de l'intervalle";


    }
    @Test
    private void testInferieurIntervalle(){
	 
	 /*    Etat après instanciation pour une valeur de départ:
		1) depart < vigieMin < vigieMax,
		2) depart = vigieMin < vigieMax.
		
		A vérifier :
		estBleu() retourne vrai.
		estVert() retourne faux.
		estRouge() retourne faux. 
	 */
	 

	 //****** 1) depart < vigieMin < vigieMax,
	 JaugeNaturel jn = new JaugeNaturel(2,100,0);
	 jn.decrementer();
	 jn.decrementer();
	 assert jn.estBleu() == true : "Blue=valeur au dehors de l'intervalle";
	 assert jn.estVert() == false : "Vert=valeur dans l'intervalle";
	 assert jn.estRouge() == false : "Rouge=valeur au dehors de l'intervalle";

	 //*********2) depart = vigieMin < vigieMax.
	 JaugeNaturel jn1 = new JaugeNaturel(2,100,0);
	 jn.decrementer();
	 jn.decrementer();
	 assert jn1.estBleu() == true : "Blue=valeur au dehors de l'intervalle";
	 assert jn1.estVert() == false : "Vert=valeur dans l'intervalle";
	 assert jn1.estRouge() == false : "Rouge=valeur au dehors de l'intervalle";
	 

	 }
    @Test
    private void testCreationNonValide() { 
	JaugeNaturel  inverse = null;
	JaugeNaturel egale= null;
	try{ 
	   
	   inverse = new JaugeNaturel(78, 13, 0);

	}
	  catch(IllegalArgumentException e) {
	      // assert false: "InvalidArgument -> impossible d'instancier la jauge inverse";
	      assert (null == inverse): "erreur";
	   
	  }   
	 
	try{
	    egale = new JaugeNaturel(-45, -45, -45); 
	}
	catch(IllegalArgumentException e) {
	    //assert false: "InvalidArgument -> impossible d'instancier la jauge egale";
	    assert (null == egale): "erreur";
	   

	}
	
	  
    }
   /* private void  testExceptionControlee() throws ClassNotFoundException{ 
	//throw new NullPointerException("Attention"); 
	throw new ClassNotFoundException("Attention") ;*/
    




 /*    A l'instanciation, vérifier l'état dans le cas limite où vigieMax < depart < vigieMin.
		L'état est-il cohérent ?

    private testLimiteVigieMaxInferieurVigieMin(){

	
	 
	 JaugeNaturel jn = new JaugeNaturel(100,2,50);
	 assert jn.estBleu() == true : "Blue=valeur au dehors de l'intervalle";
	 assert jn.estVert() == false : "Vert=valeur dans l'intervalle";
	 assert jn.estRouge() == true : "Rouge=valeur au dehors de l'intervalle";
    }

    /* private testMaxEgaleMin(){

	  
       
	 JaugeNaturel jn = new JaugeNaturel(100,100,150);
	 assert jn.estBleu() == false : "Blue=valeur au dehors de l'intervalle";
	 assert jn.estVert() == false : "Vert=valeur dans l'intervalle";
	 assert jn.estRouge() == true : "Rouge=valeur au dehors de l'intervalle";

	 JaugeNaturel jn = new JaugeNaturel(100,100,100);
	 assert jn.estBleu() == true : "Blue=valeur au dehors de l'intervalle";
	 assert jn.estVert() == false : "Vert=valeur dans l'intervalle";
	 assert jn.estRouge() == true : "Rouge=valeur au dehors de l'intervalle";
	 
    }
    */
    @Test
    private void testSuperieurIntervalle(){
	 
	 /*Etat après instanciation pour une valeur de départ:
	   1) vigieMin < vigieMax < depart
	   A vérifier :
	   estBleu() retourne faux.
	   estVert() retourne faux.
	   estRouge() retourne vrai. 
	 */ 
	 JaugeNaturel jn = new JaugeNaturel(0,100,150);
	 assert jn.estBleu() == false : "Blue=valeur au dehors de l'intervalle";
	 assert jn.estVert() == false : "Vert=valeur dans l'intervalle";
	 assert jn.estRouge() == true : "Rouge=valeur au dehors de l'intervalle";
	
	 // 2) vigieMin < vigieMax = depart.

	 JaugeNaturel jn1 = new JaugeNaturel(0,100,100);
	 assert jn1.estBleu() == false : "Blue=valeur au dehors de l'intervalle";
	 assert jn1.estVert() == false : "Vert=valeur dans l'intervalle";
	 assert jn1.estRouge() == true : "Rouge=valeur au dehors de l'intervalle";

	 }

}
